home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 21 / AACD 21.iso / AACD / Utilities / Ghostscript / src / gstype2.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-01  |  21.1 KB  |  797 lines
  1. /* Copyright (C) 1996, 2000 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of AFPL Ghostscript.
  4.   
  5.   AFPL Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author or
  6.   distributor accepts any responsibility for the consequences of using it, or
  7.   for whether it serves any particular purpose or works at all, unless he or
  8.   she says so in writing.  Refer to the Aladdin Free Public License (the
  9.   "License") for full details.
  10.   
  11.   Every copy of AFPL Ghostscript must include a copy of the License, normally
  12.   in a plain ASCII text file named PUBLIC.  The License grants you the right
  13.   to copy, modify and redistribute AFPL Ghostscript, but only under certain
  14.   conditions described in the License.  Among other things, the License
  15.   requires that the copyright notice and this notice be preserved on all
  16.   copies.
  17. */
  18.  
  19. /*$Id: gstype2.c,v 1.7.2.1 2000/11/09 21:28:19 rayjj Exp $ */
  20. /* Adobe Type 2 charstring interpreter */
  21. #include "math_.h"
  22. #include "memory_.h"
  23. #include "gx.h"
  24. #include "gserrors.h"
  25. #include "gsstruct.h"
  26. #include "gxarith.h"
  27. #include "gxfixed.h"
  28. #include "gxmatrix.h"
  29. #include "gxcoord.h"
  30. #include "gxistate.h"
  31. #include "gzpath.h"
  32. #include "gxfont.h"
  33. #include "gxfont1.h"
  34. #include "gxtype1.h"
  35.  
  36. /* NOTE: The following are not yet implemented:
  37.  *    Registry items other than 0
  38.  *    Counter masks (but they are parsed correctly)
  39.  *    'random' operator
  40.  */
  41.  
  42. /* ------ Internal routines ------ */
  43.  
  44. /*
  45.  * Set the character width.  This is provided as an optional extra operand
  46.  * on the stack for the first operator.  After setting the width, we remove
  47.  * the extra operand, and back up the interpreter pointer so we will
  48.  * re-execute the operator when control re-enters the interpreter.
  49.  */
  50. #define check_first_operator(explicit_width)\
  51.   BEGIN\
  52.     if ( pcis->init_done < 0 )\
  53.       { ipsp->ip = cip, ipsp->dstate = state;\
  54.     return type2_sbw(pcis, csp, cstack, ipsp, explicit_width);\
  55.       }\
  56.   END
  57. private int
  58. type2_sbw(gs_type1_state * pcis, cs_ptr csp, cs_ptr cstack, ip_state * ipsp,
  59.       bool explicit_width)
  60. {
  61.     fixed wx;
  62.  
  63.     if (explicit_width) {
  64.     wx = cstack[0] + pcis->pfont->data.nominalWidthX;
  65.     memmove(cstack, cstack + 1, (csp - cstack) * sizeof(*cstack));
  66.     --csp;
  67.     } else
  68.     wx = pcis->pfont->data.defaultWidthX;
  69.     gs_type1_sbw(pcis, fixed_0, fixed_0, wx, fixed_0);
  70.     /* Back up the interpretation pointer. */
  71.     {
  72.     ip_state *ipsp = &pcis->ipstack[pcis->ips_count - 1];
  73.  
  74.     ipsp->ip--;
  75.     decrypt_skip_previous(*ipsp->ip, ipsp->dstate);
  76.     }
  77.     /* Save the interpreter state. */
  78.     pcis->os_count = csp + 1 - cstack;
  79.     pcis->ips_count = ipsp - &pcis->ipstack[0] + 1;
  80.     memcpy(pcis->ostack, cstack, pcis->os_count * sizeof(cstack[0]));
  81.     if (pcis->init_done < 0) {    /* Finish init when we return. */
  82.     pcis->init_done = 0;
  83.     }
  84.     return type1_result_sbw;
  85. }
  86. private int
  87. type2_vstem(gs_type1_state * pcis, cs_ptr csp, cs_ptr cstack)
  88. {
  89.     fixed x = 0;
  90.     cs_ptr ap;
  91.  
  92.     apply_path_hints(pcis, false);
  93.     for (ap = cstack; ap + 1 <= csp; x += ap[1], ap += 2)
  94.     type1_vstem(pcis, x += ap[0], ap[1]);
  95.     pcis->num_hints += (csp + 1 - cstack) >> 1;
  96.     return 0;
  97. }
  98.  
  99. /* Enable only the hints selected by a mask. */
  100. private void
  101. enable_hints(stem_hint_table * psht, const byte * mask)
  102. {
  103.     stem_hint *table = &psht->data[0];
  104.     stem_hint *ph = table + psht->current;
  105.  
  106.     for (ph = &table[psht->count]; --ph >= table;) {
  107.     ph->active = (mask[ph->index >> 3] & (0x80 >> (ph->index & 7))) != 0;
  108.     if_debug6('1', "[1]  %s %u: %g(%g),%g(%g)\n",
  109.           (ph->active ? "enable" : "disable"), ph->index,
  110.           fixed2float(ph->v0), fixed2float(ph->dv0),
  111.           fixed2float(ph->v1), fixed2float(ph->dv1));
  112.     }
  113. }
  114.  
  115. /* ------ Main interpreter ------ */
  116.  
  117. /*
  118.  * Continue interpreting a Type 2 charstring.  If str != 0, it is taken as
  119.  * the byte string to interpret.  Return 0 on successful completion, <0 on
  120.  * error, or >0 when client intervention is required (or allowed).  The int*
  121.  * argument is only for compatibility with the Type 1 charstring interpreter.
  122.  */
  123. int
  124. gs_type2_interpret(gs_type1_state * pcis, const gs_const_string * str,
  125.            int *ignore_pindex)
  126. {
  127.     gs_font_type1 *pfont = pcis->pfont;
  128.     gs_type1_data *pdata = &pfont->data;
  129.     bool encrypted = pdata->lenIV >= 0;
  130.     gs_op1_state s;
  131.     fixed cstack[ostack_size];
  132.     cs_ptr csp;
  133. #define clear CLEAR_CSTACK(cstack, csp)
  134.     ip_state *ipsp = &pcis->ipstack[pcis->ips_count - 1];
  135.     register const byte *cip;
  136.     register crypt_state state;
  137.     register int c;
  138.     cs_ptr ap;
  139.     bool vertical;
  140.     int code = 0;
  141.  
  142. /****** FAKE THE REGISTRY ******/
  143.     struct {
  144.     float *values;
  145.     uint size;
  146.     } Registry[1];
  147.  
  148.     Registry[0].values = pcis->pfont->data.WeightVector.values;
  149.  
  150.     switch (pcis->init_done) {
  151.     case -1:
  152.         break;
  153.     case 0:
  154.         gs_type1_finish_init(pcis, &s);    /* sets sfc, ptx, pty, origin */
  155.         break;
  156.     default /*case 1 */ :
  157.         ptx = pcis->position.x;
  158.         pty = pcis->position.y;
  159.         sfc = pcis->fc;
  160.     }
  161.     sppath = pcis->path;
  162.     s.pcis = pcis;
  163.     INIT_CSTACK(cstack, csp, pcis);
  164.  
  165.     if (str == 0)
  166.     goto cont;
  167.     ipsp->char_string = *str;
  168.     cip = str->data;
  169.   call:state = crypt_charstring_seed;
  170.     if (encrypted) {
  171.     int skip = pdata->lenIV;
  172.  
  173.     /* Skip initial random bytes */
  174.     for (; skip > 0; ++cip, --skip)
  175.         decrypt_skip_next(*cip, state);
  176.     }
  177.     goto top;
  178.   cont:cip = ipsp->ip;
  179.     state = ipsp->dstate;
  180.   top:for (;;) {
  181.     uint c0 = *cip++;
  182.  
  183.     charstring_next(c0, state, c, encrypted);
  184.     if (c >= c_num1) {
  185.         /* This is a number, decode it and push it on the stack. */
  186.  
  187.         if (c < c_pos2_0) {    /* 1-byte number */
  188.         decode_push_num1(csp, c);
  189.         } else if (c < cx_num4) {    /* 2-byte number */
  190.         decode_push_num2(csp, c, cip, state, encrypted);
  191.         } else if (c == cx_num4) {    /* 4-byte number */
  192.         long lw;
  193.  
  194.         decode_num4(lw, cip, state, encrypted);
  195.         /* 32-bit numbers are 16:16. */
  196.         *++csp = arith_rshift(lw, 16 - _fixed_shift);
  197.         } else        /* not possible */
  198.         return_error(gs_error_invalidfont);
  199.       pushed:if_debug3('1', "[1]%d: (%d) %f\n",
  200.               (int)(csp - cstack), c, fixed2float(*csp));
  201.         continue;
  202.     }
  203. #ifdef DEBUG
  204.     if (gs_debug['1']) {
  205.         static const char *const c2names[] =
  206.         {char2_command_names};
  207.  
  208.         if (c2names[c] == 0)
  209.         dlprintf2("[1]0x%lx: %02x??\n", (ulong) (cip - 1), c);
  210.         else
  211.         dlprintf3("[1]0x%lx: %02x %s\n", (ulong) (cip - 1), c,
  212.               c2names[c]);
  213.     }
  214. #endif
  215.     switch ((char_command) c) {
  216. #define cnext clear; goto top
  217.  
  218.         /* Commands with identical functions in Type 1 and Type 2, */
  219.         /* except for 'escape'. */
  220.  
  221.         case c_undef0:
  222.         case c_undef2:
  223.         case c_undef17:
  224.         return_error(gs_error_invalidfont);
  225.         case c_callsubr:
  226.         c = fixed2int_var(*csp) + pdata->subroutineNumberBias;
  227.         code = (*pdata->procs.subr_data)
  228.             (pfont, c, false, &ipsp[1].char_string);
  229.           subr:if (code < 0)
  230.             return_error(code);
  231.         --csp;
  232.         ipsp->ip = cip, ipsp->dstate = state;
  233.         ++ipsp;
  234.         cip = ipsp->char_string.data;
  235.         goto call;
  236.         case c_return:
  237.         --ipsp;
  238.         goto cont;
  239.         case c_undoc15:
  240.         /* See gstype1.h for information on this opcode. */
  241.         cnext;
  242.  
  243.         /* Commands with similar but not identical functions */
  244.         /* in Type 1 and Type 2 charstrings. */
  245.  
  246.         case cx_hstem:
  247.         goto hstem;
  248.         case cx_vstem:
  249.         goto vstem;
  250.         case cx_vmoveto:
  251.         /*
  252.          * Type 2 CharStrings, unlike Type 1, insert an explicit
  253.          * closepath before a moveto rather than an implicit one.
  254.          * (This makes a difference for charpath.)  Note that if
  255.          * we are just getting the glyph info, sppath may be 0:
  256.          * this is OK, because check_first_operator will return.
  257.          */
  258.         if (pfont->PaintType != 1 && sppath != 0) {
  259.             code = gx_path_close_subpath(sppath);
  260.             if (code < 0)
  261.             return code;
  262.         }
  263.         check_first_operator(csp > cstack);
  264.         accum_y(*csp);
  265.           move:if ((pcis->hint_next != 0 || path_is_drawing(sppath)))
  266.             apply_path_hints(pcis, true);
  267.         code = gx_path_add_point(sppath, ptx, pty);
  268.           cc:if (code < 0)
  269.             return code;
  270.         goto pp;
  271.         case cx_rlineto:
  272.         for (ap = cstack; ap + 1 <= csp; ap += 2) {
  273.             accum_xy(ap[0], ap[1]);
  274.             code = gx_path_add_line(sppath, ptx, pty);
  275.             if (code < 0)
  276.             return code;
  277.         }
  278.           pp:if_debug2('1', "[1]pt=(%g,%g)\n",
  279.               fixed2float(ptx), fixed2float(pty));
  280.         cnext;
  281.         case cx_hlineto:
  282.         vertical = false;
  283.         goto hvl;
  284.         case cx_vlineto:
  285.         vertical = true;
  286.           hvl:for (ap = cstack; ap <= csp; vertical = !vertical, ++ap) {
  287.             if (vertical)
  288.             accum_y(*ap);
  289.             else
  290.             accum_x(*ap);
  291.             code = gx_path_add_line(sppath, ptx, pty);
  292.             if (code < 0)
  293.             return code;
  294.         }
  295.         goto pp;
  296.         case cx_rrcurveto:
  297.         for (ap = cstack; ap + 5 <= csp; ap += 6) {
  298.             code = gs_op1_rrcurveto(&s, ap[0], ap[1], ap[2],
  299.                         ap[3], ap[4], ap[5]);
  300.             if (code < 0)
  301.             return code;
  302.         }
  303.         goto pp;
  304.         case cx_endchar:
  305.         /*
  306.          * See vmoveto above re closing the subpath.  Note that
  307.          * sppath may be 0 if we are just getting the glyph info.
  308.          */
  309.         if (pfont->PaintType != 1 && sppath != 0) {
  310.             code = gx_path_close_subpath(sppath);
  311.             if (code < 0)
  312.             return code;
  313.         }
  314.         /*
  315.          * It is an undocumented (!) feature of Type 2 CharStrings
  316.          * that if endchar is invoked with 4 or 5 operands, it is
  317.          * equivalent to the Type 1 seac operator!  In this case,
  318.          * the asb operand of seac is missing: we assume it is
  319.          * the same as the l.s.b. of the accented character.
  320.          */
  321.         if (csp >= cstack + 3) {
  322.             check_first_operator(csp > cstack + 3);
  323.             code = gs_type1_seac(pcis, cstack, pcis->lsb.x, ipsp);
  324.             if (code < 0)
  325.             return code;
  326.             clear;
  327.             cip = ipsp->char_string.data;
  328.             goto call;
  329.         }
  330.         /*
  331.          * This might be the only operator in the charstring.
  332.          * In this case, there might be a width on the stack.
  333.          */
  334.         check_first_operator(csp >= cstack);
  335.         code = gs_type1_endchar(pcis);
  336.         if (code == 1) {
  337.             /*
  338.              * Reset the total hint count so that hintmask will
  339.              * parse its following data correctly.
  340.              * (gs_type1_endchar already reset the actual hint
  341.              * tables.)
  342.              */
  343.             pcis->num_hints = 0;
  344.             /* do accent of seac */
  345.             spt = pcis->position;
  346.             ipsp = &pcis->ipstack[pcis->ips_count - 1];
  347.             cip = ipsp->char_string.data;
  348.             goto call;
  349.         }
  350.         return code;
  351.         case cx_rmoveto:
  352.         /* See vmoveto above re closing the subpath. */
  353.         if (pfont->PaintType != 1 && sppath != 0) {
  354.             code = gx_path_close_subpath(sppath);
  355.             if (code < 0)
  356.             return code;
  357.         }
  358.         check_first_operator(csp > cstack + 1);
  359.         accum_xy(csp[-1], *csp);
  360.         goto move;
  361.         case cx_hmoveto:
  362.         /* See vmoveto above re closing the subpath. */
  363.         if (pfont->PaintType != 1 && sppath != 0) {
  364.             code = gx_path_close_subpath(sppath);
  365.             if (code < 0)
  366.             return code;
  367.         }
  368.         check_first_operator(csp > cstack);
  369.         accum_x(*csp);
  370.         goto move;
  371.         case cx_vhcurveto:
  372.         vertical = true;
  373.         goto hvc;
  374.         case cx_hvcurveto:
  375.         vertical = false;
  376.           hvc:for (ap = cstack; ap + 3 <= csp; vertical = !vertical, ap += 4) {
  377.             gs_fixed_point pt1, pt2;
  378.             fixed ax0 = sppath->position.x - ptx;
  379.             fixed ay0 = sppath->position.y - pty;
  380.  
  381.             if (vertical)
  382.             accum_y(ap[0]);
  383.             else
  384.             accum_x(ap[0]);
  385.             pt1.x = ptx + ax0, pt1.y = pty + ay0;
  386.             accum_xy(ap[1], ap[2]);
  387.             pt2.x = ptx, pt2.y = pty;
  388.             if (vertical) {
  389.             if (ap + 4 == csp)
  390.                 accum_xy(ap[3], ap[4]);
  391.             else
  392.                 accum_x(ap[3]);
  393.             } else {
  394.             if (ap + 4 == csp)
  395.                 accum_xy(ap[4], ap[3]);
  396.             else
  397.                 accum_y(ap[3]);
  398.             }
  399.             code = gx_path_add_curve(sppath, pt1.x, pt1.y,
  400.                          pt2.x, pt2.y, ptx, pty);
  401.             if (code < 0)
  402.             return code;
  403.         }
  404.         goto pp;
  405.  
  406.             /***********************
  407.              * New Type 2 commands *
  408.              ***********************/
  409.  
  410.         case c2_blend:
  411.         {
  412.             int n = fixed2int_var(*csp);
  413.             int num_values = csp - cstack;
  414.             gs_font_type1 *pfont = pcis->pfont;
  415.             int k = pfont->data.WeightVector.count;
  416.             int i, j;
  417.             cs_ptr base, deltas;
  418.  
  419.             base = csp - 1 - num_values;
  420.             deltas = base + n - 1;
  421.             for (j = 0; j < n; j++, base++, deltas += k - 1)
  422.             for (i = 1; i < k; i++)
  423.                 *base += deltas[i] * pfont->data.WeightVector.values[i];
  424.         }
  425.         cnext;
  426.         case c2_hstemhm:
  427.         pcis->have_hintmask = true;
  428.           hstem:check_first_operator(!((csp - cstack) & 1));
  429.         apply_path_hints(pcis, false);
  430.         {
  431.             fixed x = 0;
  432.  
  433.             for (ap = cstack; ap + 1 <= csp; x += ap[1], ap += 2)
  434.             type1_hstem(pcis, x += ap[0], ap[1]);
  435.         }
  436.         pcis->num_hints += (csp + 1 - cstack) >> 1;
  437.         cnext;
  438.         case c2_hintmask:
  439.         /*
  440.          * A hintmask at the beginning of the CharString is
  441.          * equivalent to vstemhm + hintmask.  For simplicity, we use
  442.          * this interpretation everywhere.
  443.          *
  444.          * Even though the Adobe documentation doesn't say this,
  445.          * it appears that the same holds true for cntrmask.
  446.          */
  447.         case c2_cntrmask:
  448.         pcis->have_hintmask = true;
  449.         check_first_operator(!((csp - cstack) & 1));
  450.         type2_vstem(pcis, csp, cstack);
  451.         /*
  452.          * We should clear the stack here only if this is the
  453.          * initial mask operator that includes the implicit
  454.          * vstemhm, but currently this is too much trouble to
  455.          * detect.
  456.          */
  457.         clear;
  458.         {
  459.             byte mask[max_total_stem_hints / 8];
  460.             int i;
  461.  
  462.             if_debug3('1', "[1]mask[%d:%dh,%dv]", pcis->num_hints,
  463.               pcis->hstem_hints.count, pcis->vstem_hints.count);
  464.             for (i = 0; i < pcis->num_hints; ++cip, i += 8) {
  465.             charstring_next(*cip, state, mask[i >> 3], encrypted);
  466.             if_debug1('1', " 0x%02x", mask[i >> 3]);
  467.             }
  468.             if_debug0('1', "\n");
  469.             ipsp->ip = cip;
  470.             ipsp->dstate = state;
  471.             if (c == c2_cntrmask) {
  472. /****** NYI ******/
  473.             } else {    /* hintmask or equivalent */
  474.             if_debug0('1', "[1]hstem hints:\n");
  475.             enable_hints(&pcis->hstem_hints, mask);
  476.             if_debug0('1', "[1]vstem hints:\n");
  477.             enable_hints(&pcis->vstem_hints, mask);
  478.             }
  479.         }
  480.         break;
  481.         case c2_vstemhm:
  482.         pcis->have_hintmask = true;
  483.           vstem:check_first_operator(!((csp - cstack) & 1));
  484.         type2_vstem(pcis, csp, cstack);
  485.         cnext;
  486.         case c2_rcurveline:
  487.         for (ap = cstack; ap + 5 <= csp; ap += 6) {
  488.             code = gs_op1_rrcurveto(&s, ap[0], ap[1], ap[2], ap[3],
  489.                         ap[4], ap[5]);
  490.             if (code < 0)
  491.             return code;
  492.         }
  493.         accum_xy(ap[0], ap[1]);
  494.         code = gx_path_add_line(sppath, ptx, pty);
  495.         goto cc;
  496.         case c2_rlinecurve:
  497.         for (ap = cstack; ap + 7 <= csp; ap += 2) {
  498.             accum_xy(ap[0], ap[1]);
  499.             code = gx_path_add_line(sppath, ptx, pty);
  500.             if (code < 0)
  501.             return code;
  502.         }
  503.         code = gs_op1_rrcurveto(&s, ap[0], ap[1], ap[2], ap[3],
  504.                     ap[4], ap[5]);
  505.         goto cc;
  506.         case c2_vvcurveto:
  507.         ap = cstack;
  508.         {
  509.             int n = csp + 1 - cstack;
  510.             fixed dxa = (n & 1 ? *ap++ : 0);
  511.  
  512.             for (; ap + 3 <= csp; ap += 4) {
  513.             code = gs_op1_rrcurveto(&s, dxa, ap[0], ap[1], ap[2],
  514.                         fixed_0, ap[3]);
  515.             if (code < 0)
  516.                 return code;
  517.             dxa = 0;
  518.             }
  519.         }
  520.         goto pp;
  521.         case c2_hhcurveto:
  522.         ap = cstack;
  523.         {
  524.             int n = csp + 1 - cstack;
  525.             fixed dya = (n & 1 ? *ap++ : 0);
  526.  
  527.             for (; ap + 3 <= csp; ap += 4) {
  528.             code = gs_op1_rrcurveto(&s, ap[0], dya, ap[1], ap[2],
  529.                         ap[3], fixed_0);
  530.             if (code < 0)
  531.                 return code;
  532.             dya = 0;
  533.             }
  534.         }
  535.         goto pp;
  536.         case c2_shortint:
  537.         {
  538.             int c1, c2;
  539.  
  540.             charstring_next(*cip, state, c1, encrypted);
  541.             ++cip;
  542.             charstring_next(*cip, state, c2, encrypted);
  543.             ++cip;
  544.             *++csp = int2fixed((((c1 ^ 0x80) - 0x80) << 8) + c2);
  545.         }
  546.         goto pushed;
  547.         case c2_callgsubr:
  548.         c = fixed2int_var(*csp) + pdata->gsubrNumberBias;
  549.         code = (*pdata->procs.subr_data)
  550.             (pfont, c, true, &ipsp[1].char_string);
  551.         goto subr;
  552.         case cx_escape:
  553.         charstring_next(*cip, state, c, encrypted);
  554.         ++cip;
  555. #ifdef DEBUG
  556.         if (gs_debug['1'] && c < char2_extended_command_count) {
  557.             static const char *const ce2names[] =
  558.             {char2_extended_command_names};
  559.  
  560.             if (ce2names[c] == 0)
  561.             dlprintf2("[1]0x%lx: %02x??\n", (ulong) (cip - 1), c);
  562.             else
  563.             dlprintf3("[1]0x%lx: %02x %s\n", (ulong) (cip - 1), c,
  564.                   ce2names[c]);
  565.         }
  566. #endif
  567.         switch ((char2_extended_command) c) {
  568.             case ce2_and:
  569.             csp[-1] = ((csp[-1] != 0) & (*csp != 0) ? fixed_1 : 0);
  570.             --csp;
  571.             break;
  572.             case ce2_or:
  573.             csp[-1] = (csp[-1] | *csp ? fixed_1 : 0);
  574.             --csp;
  575.             break;
  576.             case ce2_not:
  577.             *csp = (*csp ? 0 : fixed_1);
  578.             break;
  579.             case ce2_store:
  580.             {
  581.                 int i, n = fixed2int_var(*csp);
  582.                 float *to = Registry[fixed2int_var(csp[-3])].values +
  583.                 fixed2int_var(csp[-2]);
  584.                 const fixed *from =
  585.                 pcis->transient_array + fixed2int_var(csp[-1]);
  586.  
  587.                 for (i = 0; i < n; ++i)
  588.                 to[i] = fixed2float(from[i]);
  589.             }
  590.             csp -= 4;
  591.             break;
  592.             case ce2_abs:
  593.             if (*csp < 0)
  594.                 *csp = -*csp;
  595.             break;
  596.             case ce2_add:
  597.             csp[-1] += *csp;
  598.             --csp;
  599.             break;
  600.             case ce2_sub:
  601.             csp[-1] -= *csp;
  602.             --csp;
  603.             break;
  604.             case ce2_div:
  605.             csp[-1] = float2fixed((double)csp[-1] / *csp);
  606.             --csp;
  607.             break;
  608.             case ce2_load:
  609.             /* The specification says there is no j (starting index */
  610.             /* in registry array) argument.... */
  611.             {
  612.                 int i, n = fixed2int_var(*csp);
  613.                 const float *from = Registry[fixed2int_var(csp[-2])].values;
  614.                 fixed *to =
  615.                 pcis->transient_array + fixed2int_var(csp[-1]);
  616.  
  617.                 for (i = 0; i < n; ++i)
  618.                 to[i] = float2fixed(from[i]);
  619.             }
  620.             csp -= 3;
  621.             break;
  622.             case ce2_neg:
  623.             *csp = -*csp;
  624.             break;
  625.             case ce2_eq:
  626.             csp[-1] = (csp[-1] == *csp ? fixed_1 : 0);
  627.             --csp;
  628.             break;
  629.             case ce2_drop:
  630.             --csp;
  631.             break;
  632.             case ce2_put:
  633.             pcis->transient_array[fixed2int_var(*csp)] = csp[-1];
  634.             csp -= 2;
  635.             break;
  636.             case ce2_get:
  637.             *csp = pcis->transient_array[fixed2int_var(*csp)];
  638.             break;
  639.             case ce2_ifelse:
  640.             if (csp[-1] > *csp)
  641.                 csp[-3] = csp[-2];
  642.             csp -= 3;
  643.             break;
  644.             case ce2_random:
  645.             ++csp;
  646.             /****** NYI ******/
  647.             break;
  648.             case ce2_mul:
  649.             {
  650.                 double prod = fixed2float(csp[-1]) * *csp;
  651.  
  652.                 csp[-1] =
  653.                 (prod > max_fixed ? max_fixed :
  654.                  prod < min_fixed ? min_fixed : prod);
  655.             }
  656.             --csp;
  657.             break;
  658.             case ce2_sqrt:
  659.             if (*csp >= 0)
  660.                 *csp = float2fixed(sqrt(fixed2float(*csp)));
  661.             break;
  662.             case ce2_dup:
  663.             csp[1] = *csp;
  664.             ++csp;
  665.             break;
  666.             case ce2_exch:
  667.             {
  668.                 fixed top = *csp;
  669.  
  670.                 *csp = csp[-1], csp[-1] = top;
  671.             }
  672.             break;
  673.             case ce2_index:
  674.             *csp =
  675.                 (*csp < 0 ? csp[-1] : csp[-1 - fixed2int_var(csp[-1])]);
  676.             break;
  677.             case ce2_roll:
  678.             {
  679.                 int distance = fixed2int_var(*csp);
  680.                 int count = fixed2int_var(csp[-1]);
  681.                 cs_ptr bot;
  682.  
  683.                 csp -= 2;
  684.                 if (count < 0 || count > csp + 1 - cstack)
  685.                 return_error(gs_error_invalidfont);
  686.                 if (count == 0)
  687.                 break;
  688.                 if (distance < 0)
  689.                 distance = count - (-distance % count);
  690.                 bot = csp + 1 - count;
  691.                 while (--distance >= 0) {
  692.                 fixed top = *csp;
  693.  
  694.                 memmove(bot + 1, bot,
  695.                     (count - 1) * sizeof(fixed));
  696.                 *bot = top;
  697.                 }
  698.             }
  699.             break;
  700.             case ce2_hflex:
  701.             csp[6] = fixed_half;    /* fd/100 */
  702.             csp[4] = *csp, csp[5] = 0;    /* dx6, dy6 */
  703.             csp[2] = csp[-1], csp[3] = -csp[-4];    /* dx5, dy5 */
  704.             *csp = csp[-2], csp[1] = 0;    /* dx4, dy4 */
  705.             csp[-2] = csp[-3], csp[-1] = 0;        /* dx3, dy3 */
  706.             csp[-3] = csp[-4], csp[-4] = csp[-5];    /* dx2, dy2 */
  707.             csp[-5] = 0;    /* dy1 */
  708.             csp += 6;
  709.             goto flex;
  710.             case ce2_flex:
  711.             *csp /= 100;    /* fd/100 */
  712. flex:            {
  713.                 fixed x_join = csp[-12] + csp[-10] + csp[-8];
  714.                 fixed y_join = csp[-11] + csp[-9] + csp[-7];
  715.                 fixed x_end = x_join + csp[-6] + csp[-4] + csp[-2];
  716.                 fixed y_end = y_join + csp[-5] + csp[-3] + csp[-1];
  717.                 gs_point join, end;
  718.                 double flex_depth;
  719.  
  720.                 if ((code =
  721.                  gs_distance_transform(fixed2float(x_join),
  722.                                fixed2float(y_join),
  723.                                &ctm_only(pcis->pis),
  724.                                &join)) < 0 ||
  725.                 (code =
  726.                  gs_distance_transform(fixed2float(x_end),
  727.                                fixed2float(y_end),
  728.                                &ctm_only(pcis->pis),
  729.                                &end)) < 0
  730.                 )
  731.                 return code;
  732.                 /*
  733.                  * Use the X or Y distance depending on whether
  734.                  * the curve is more horizontal or more
  735.                  * vertical.
  736.                  */
  737.                 if (any_abs(end.y) > any_abs(end.x))
  738.                 flex_depth = join.x;
  739.                 else
  740.                 flex_depth = join.y;
  741.                 if (fabs(flex_depth) < fixed2float(*csp)) {
  742.                 /* Do flex as line. */
  743.                 accum_xy(x_end, y_end);
  744.                 code = gx_path_add_line(sppath, ptx, pty);
  745.                 } else {
  746.                 /*
  747.                  * Do flex as curve.  We can't jump to rrc,
  748.                  * because the flex operators don't clear
  749.                  * the stack (!).
  750.                  */
  751.                 code = gs_op1_rrcurveto(&s,
  752.                     csp[-12], csp[-11], csp[-10],
  753.                     csp[-9], csp[-8], csp[-7]);
  754.                 if (code < 0)
  755.                     return code;
  756.                 code = gs_op1_rrcurveto(&s,
  757.                     csp[-6], csp[-5], csp[-4],
  758.                     csp[-3], csp[-2], csp[-1]);
  759.                 }
  760.                 if (code < 0)
  761.                 return code;
  762.                 csp -= 13;
  763.             }
  764.             cnext;
  765.             case ce2_hflex1:
  766.             csp[4] = fixed_half;    /* fd/100 */
  767.             csp[2] = *csp, csp[3] = 0;    /* dx6, dy6 */
  768.             *csp = csp[-2], csp[1] = csp[-1];    /* dx5, dy5 */
  769.             csp[-2] = csp[-3], csp[-1] = 0;        /* dx4, dy4 */
  770.             csp[-3] = 0;    /* dy3 */
  771.             csp += 4;
  772.             goto flex;
  773.             case ce2_flex1:
  774.             {
  775.                 fixed dx = csp[-10] + csp[-8] + csp[-6] + csp[-4] + csp[-2];
  776.                 fixed dy = csp[-9] + csp[-7] + csp[-5] + csp[-3] + csp[-1];
  777.  
  778.                 if (any_abs(dx) > any_abs(dy))
  779.                 csp[1] = -dy;    /* d6 is dx6 */
  780.                 else
  781.                 csp[1] = *csp, *csp = -dx;    /* d6 is dy6 */
  782.             }
  783.             csp[2] = fixed_half;    /* fd/100 */
  784.             csp += 2;
  785.             goto flex;
  786.         }
  787.         break;
  788.  
  789.         /* Fill up the dispatch up to 32. */
  790.  
  791.           case_c2_undefs:
  792.         default:        /* pacify compiler */
  793.         return_error(gs_error_invalidfont);
  794.     }
  795.     }
  796. }
  797.